﻿using System;
using System.Collections.Generic;
using Bastanteo.Dominio;
using Bastanteo.Persistencia;
using NUnit.Framework;

namespace Bastanteo.Pruebas
{
    public class Test5_BastanteoDAO
    {

        IBastanteoDAO bastanteoDAO = null;
        IGrupoDAO grupoDAO = null;
        IPoderDAO poderDAO = null;

        CBastanteo bastanteoCreado = null;

        Grupo codigoGrupo = null;
        Poder codigoPoder = null;

        Int32 NuevoBastanteo = 0;
        Int32 NuevoGrupo = 0;
        Int32 NuevoPoder = 0;

        [TestFixtureSetUp]
        public void InicializarPruebas()
        {
            bastanteoDAO = new Persistencia.NH.BastanteoDAO(); // Instanciamos la implementación elegida (ADO o NHibernate)
            grupoDAO = new Persistencia.NH.GrupoDAO();
            poderDAO = new Persistencia.NH.PoderDAO();

            codigoGrupo = grupoDAO.Crear(new Grupo() { Descripcion = "GRUPO 01" });
            NuevoGrupo  = codigoGrupo.CodigoGrupo;

            codigoPoder = poderDAO.Crear(new Poder() { Descripcion = "PODER", TipoProducto = "Z" });
            NuevoPoder  = codigoPoder.CodigoPoder;

            foreach (CBastanteo bastanteo in bastanteoDAO.ListarTodos())
                bastanteoDAO.Eliminar(bastanteo);
        }

        [Test]
        public void Test1_Crear()
        {
            // 1. Validar que ocurra un error al intentar crear un Bastanteo con un dato nulo
            CBastanteo bastanteoACrear = new CBastanteo();


            bastanteoACrear.ImporteLimite = 100.00;
            bastanteoACrear.FechaVencimiento = DateTime.Now;
            bastanteoACrear.TipoIntervencion = "A";
            Assert.Catch<Exception>(delegate
            {
                bastanteoCreado = bastanteoDAO.Crear(bastanteoACrear);
            });
            // 2. Validar que se cree un Bastanteo correctamente (sin error)
            bastanteoACrear.CodigoGrupo = codigoGrupo;
            bastanteoACrear.CodigoPoder = codigoPoder;

            Assert.DoesNotThrow(delegate
            {
                bastanteoCreado = bastanteoDAO.Crear(bastanteoACrear);
            });
            NuevoBastanteo = bastanteoACrear.CodigoBastanteo; //Obtenemos el Codigo de Bastanteo
            // 3. Validar que el Bastanteo creado no sea nulo, que el codigo grupo y poder sea el ingresado
            Assert.IsNotNull(bastanteoCreado);
            Assert.Greater(bastanteoCreado.CodigoBastanteo, 0);
            Assert.AreEqual(bastanteoCreado.CodigoGrupo, bastanteoACrear.CodigoGrupo);
            Assert.AreEqual(bastanteoCreado.CodigoPoder, bastanteoACrear.CodigoPoder);
        }

        [Test]
        public void Test2_Obtener()
        {
            CBastanteo bastanteoObtenido = null;
            // 1. Validar que se retorne nulo al obtener un Bastanteo inexistente
            Assert.DoesNotThrow(delegate
            {
                bastanteoObtenido = bastanteoDAO.Obtener(0);  //bastanteoCreado.CodigoBastanteo
            });
            Assert.IsNull(bastanteoObtenido);

            // 2. Validar que se obtenga el Bastanteo creado satisfactoriamente
            Assert.DoesNotThrow(delegate
            {
                bastanteoObtenido = bastanteoDAO.Obtener(bastanteoCreado.CodigoBastanteo);
            });
            Assert.IsNotNull(bastanteoObtenido);
            // 3. Validar que el "CodigoBastanteo" obtenido sea el creado anteriormente
            Assert.AreEqual(bastanteoObtenido.CodigoBastanteo, NuevoBastanteo);   //1
        }

        [Test]
        public void Test3_Modificar()
        {
            CBastanteo bastanteoAModificar = bastanteoDAO.Obtener(bastanteoCreado.CodigoBastanteo);
            bastanteoAModificar.ImporteLimite = 100.00;
            bastanteoAModificar.FechaVencimiento = DateTime.Now;
            bastanteoAModificar.TipoIntervencion = "A";
            bastanteoAModificar.CodigoGrupo = null;
            bastanteoAModificar.CodigoPoder = null;

            CBastanteo bastanteoModificado = null;
            // 1. Validar que ocurrar un error al intentar modificar el bastanteto con un codigopoder/grupo nulo
            Assert.Catch<Exception>(delegate
            {
                bastanteoModificado = bastanteoDAO.Modificar(bastanteoAModificar);
                //clienteModificado = clienteDAO.Modificar(clienteAModificar);
            });

            // 2. Validar que se modifique correctamente el Bastanteo
            bastanteoAModificar.CodigoGrupo = codigoGrupo;
            bastanteoAModificar.CodigoPoder = codigoPoder;
            Assert.DoesNotThrow(delegate
            {
                bastanteoModificado = bastanteoDAO.Modificar(bastanteoAModificar);
                //bastanteoAModificar = bastanteoDAO.Modificar(bastanteoAModificar);
            });
            // 3. Validar que el Bastnateo modificado no sea nulo, todos los datos indicados
            Assert.IsNotNull(bastanteoModificado);
            Assert.AreEqual(bastanteoAModificar.ImporteLimite, bastanteoModificado.ImporteLimite);
            Assert.AreEqual(bastanteoAModificar.FechaVencimiento, bastanteoModificado.FechaVencimiento);
            Assert.AreEqual(bastanteoAModificar.TipoIntervencion, bastanteoModificado.TipoIntervencion);
            Assert.AreEqual(bastanteoAModificar.CodigoGrupo, bastanteoModificado.CodigoGrupo);
            Assert.AreEqual(bastanteoAModificar.CodigoPoder, bastanteoModificado.CodigoPoder);
        }
        [Test]
        public void Test4_Eliminar()
        {
            CBastanteo bastanteoAEliminar = bastanteoDAO.Obtener(bastanteoCreado.CodigoBastanteo);
            // 1. Validar que ocurre un error si se intenta eliminar un Bastanteo nulo
            Assert.Catch<Exception>(delegate
            {
                bastanteoDAO.Eliminar(null);
            });
            // 2. Validar que se elimina correctamente el Bastanteo creado
            Assert.DoesNotThrow(delegate
            {
                bastanteoDAO.Eliminar(bastanteoAEliminar);
            });
            // 3. Validar que luego de eliminado se retorne nulo al obtenerlo
            CBastanteo bastanteoEliminado = bastanteoDAO.Obtener(bastanteoCreado.CodigoBastanteo);
            Assert.IsNull(bastanteoEliminado);

        }
 
        [Test]
        public void Test5_Listar()
        {
            bastanteoDAO.Crear(new CBastanteo() { CodigoGrupo = grupoDAO.Obtener(NuevoGrupo), CodigoPoder = poderDAO.Obtener(NuevoPoder), ImporteLimite = 20.00, FechaVencimiento = DateTime.Now, TipoIntervencion = "A" });
            bastanteoDAO.Crear(new CBastanteo() { CodigoGrupo = grupoDAO.Obtener(NuevoGrupo), CodigoPoder = poderDAO.Obtener(NuevoPoder), ImporteLimite = 20.00, FechaVencimiento = DateTime.Now, TipoIntervencion = "A" });


            // 1. Validar que se listen los Bastanteos existentes de forma correcta
            ICollection<CBastanteo> bastanteosExistentes = null;
            Assert.DoesNotThrow(delegate
            {
                bastanteosExistentes = bastanteoDAO.ListarTodos();
            });
            // 2. Validar que se retornen al menos los 2 Bastanteos creados previamente
            Assert.GreaterOrEqual(bastanteosExistentes.Count, 2); //2
            // 3. Validar que cada cliente obtenido tenga un ID no nulo
            foreach (CBastanteo Bastanteo in bastanteosExistentes)
                Assert.IsNotNull(Bastanteo.CodigoBastanteo);
        }

        [TestFixtureTearDown]
        public void FinalizarPruebas()
        {
            foreach (CBastanteo bastanteo in bastanteoDAO.ListarTodos())
                bastanteoDAO.Eliminar(bastanteo);

            grupoDAO.Eliminar(codigoGrupo);
            poderDAO.Eliminar(codigoPoder);

            Persistencia.NH.NHibernateHelper.CerrarFabrica();
        }

    }
}